//分类接口
var express = require('express');
var router = express.Router();
const connection = require('./db/conn'); // 引入数据库连接
const { v4: uuidv4 } = require('uuid'); // 引入UUID生成器

/**
 * UUID格式验证函数
 * @param {string} uuid - 要验证的UUID字符串
 * @returns {boolean} 是否为有效的UUID格式
 */
function isValidUUID(uuid) {
    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
    return typeof uuid === 'string' && uuidRegex.test(uuid);
}

/**
 * 分类管理模块 - 完整的CRUD操作
 * 基于catalog_category表设计实现分类的增删改查功能
 */
/**
 * 创建分类 - POST /category
 * @description 创建新的分类记录，使用UUID生成唯一ID
 * @body {Object} category - 分类信息
 * @body {string} category.name - 分类名称 (必填)
 * @returns {Object} 创建结果和分类UUID
 */
router.post('/category', (req, res) => {
    const { name } = req.body;

    // 参数验证
    if (!name || typeof name !== 'string' || name.trim() === '') {
        return res.status(400).json({
            success: false,
            message: '分类名称为必填项且不能为空'
        });
    }

    // 生成UUID作为分类ID
    const categoryId = uuidv4();

    const sql = `
        INSERT INTO catalog_category (id, name) 
        VALUES (?, ?)
    `;

    const values = [categoryId, name.trim()];

    connection.query(sql, values, (err, result) => {
        if (err) {
            console.error('创建分类失败:', err);
            return res.status(500).json({
                success: false,
                message: '创建分类失败',
                error: err.message
            });
        }

        res.status(201).json({
            success: true,
            message: '分类创建成功',
        });
    });
});

/**
 * 获取分类列表 - GET /category
 * @description 获取所有分类列表，按创建时间倒序排列（不分页）
 * @returns {Object} 全部分类列表
 */
router.get('/category', (req, res) => {
    // 1. 先查总条数
    const countSql = `SELECT COUNT(*) as total FROM catalog_category`;
    connection.query(countSql, (err, countResult) => {
        if (err) {
            console.error('查询总数失败:', err);
            return res.status(500).json({
                success: false,
                message: '查询总数失败',
                error: err.message
            });
        }

        const total = countResult[0].total;

        // 2. 再查全部分类
        const listSql = `
            SELECT id, name, created_at
            FROM catalog_category
            ORDER BY created_at DESC
        `;
        connection.query(listSql, (err, results) => {
            if (err) {
                console.error('查询分类列表失败:', err);
                return res.status(500).json({
                    success: false,
                    message: '查询分类列表失败',
                    error: err.message
                });
            }

            res.json({
                success: true,
                message: '查询成功',
                data: {
                    categories: results,
                    total_count: total   // ← 前端直接拿这个字段
                }
            });
        });
    });
});



/**
 * 更新分类 - PUT /category/:id
 * @description 更新指定ID的分类信息
 * @param {string} id - 分类UUID
 * @body {Object} category - 分类信息
 * @body {string} category.name - 分类名称 (必填)
 * @returns {Object} 更新结果
 */
router.put('/category/:id', (req, res) => {
    const { id } = req.params;
    const { name } = req.body;

    // UUID格式验证
    if (!isValidUUID(id)) {
        return res.status(400).json({
            success: false,
            message: '无效的分类ID格式'
        });
    }

    // 参数验证
    if (!name || typeof name !== 'string' || name.trim() === '') {
        return res.status(400).json({
            success: false,
            message: '分类名称为必填项且不能为空'
        });
    }

    // 先检查分类是否存在
    const checkSql = 'SELECT id FROM catalog_category WHERE id = ?';
    
    connection.query(checkSql, [id], (err, checkResults) => {
        if (err) {
            console.error('检查分类存在性失败:', err);
            return res.status(500).json({
                success: false,
                message: '检查分类存在性失败',
                error: err.message
            });
        }

        if (checkResults.length === 0) {
            return res.status(404).json({
                success: false,
                message: '分类不存在'
            });
        }

        // 执行更新
        const updateSql = `
            UPDATE catalog_category 
            SET name = ? 
            WHERE id = ?
        `;

        connection.query(updateSql, [name.trim(), id], (err, result) => {
            if (err) {
                console.error('更新分类失败:', err);
                return res.status(500).json({
                    success: false,
                    message: '更新分类失败',
                    error: err.message
                });
            }

            res.json({
                success: true,
                message: '分类更新成功',
            });
        });
    });
});

// 问题原因： Express.js 中路由是按照定义顺序进行匹配的。之前的路由定义顺序是：

// 1. 1.
//    DELETE /category/:id (通用路由，会匹配任何 /category/xxx 格式)
// 2. 2.
//    DELETE /category/batch (具体路由)
// 当前端请求 DELETE /category/batch 时，Express首先匹配到 DELETE /category/:id 路由，将 batch 当作 :id 参数处理，导致请求被错误地路由到单个删除的处理函数。

// 解决方案： 我已经将 `category.js` 中的路由顺序调整为：

// 1. 1.
//    DELETE /category/batch (具体路由，第197行)
// 2. 2.
//    DELETE /category/:id (通用路由，第287行)
// 现在当前端调用 DELETE /category/batch 时，会正确匹配到批量删除路由，而不会被单个删除路由拦截。

// 验证结果：

// - ✅ 批量删除路由已移动到正确位置
// - ✅ 路由匹配顺序已修复



/**
 * 批量删除分类 - DELETE /category/batch
 * @description 批量删除多个分类
 * @body {Object} request - 请求体
 * @body {string[]} request.ids - 要删除的分类ID数组
 * @returns {Object} 批量删除结果
 */
router.delete('/category/batch', (req, res) => {
    const { ids } = req.body;
    console.log(ids,'ids....');
    

    // 参数验证
    if (!Array.isArray(ids) || ids.length === 0) {
        return res.status(400).json({
            success: false,
            message: '请提供要删除的分类ID数组'
        });
    }

    // 验证所有ID格式
    const invalidIds = ids.filter(id => !isValidUUID(id));
    console.log(invalidIds,'invalidIds....');
    
    if (invalidIds.length > 0) {
        return res.status(400).json({
            success: false,
            message: '存在无效的分类ID格式',
            data: { invalid_ids: invalidIds }
        });
    }

    // 去重处理
    const uniqueIds = [...new Set(ids)];

    // 先查询要删除的分类信息
    const placeholders = uniqueIds.map(() => '?').join(',');
    const checkSql = `SELECT id, name FROM catalog_category WHERE id IN (${placeholders})`;

    connection.query(checkSql, uniqueIds, (err, checkResults) => {
        if (err) {
            console.error('查询待删除分类失败:', err);
            return res.status(500).json({
                success: false,
                message: '查询待删除分类失败',
                error: err.message
            });
        }

        const existingIds = checkResults.map(item => item.id);
        const notFoundIds = uniqueIds.filter(id => !existingIds.includes(id));

        if (existingIds.length === 0) {
            return res.status(404).json({
                success: false,
                message: '没有找到要删除的分类',
                data: { not_found_ids: notFoundIds }
            });
        }

        // 执行批量删除
        const deleteSql = `DELETE FROM catalog_category WHERE id IN (${existingIds.map(() => '?').join(',')})`;

        connection.query(deleteSql, existingIds, (err, result) => {
            if (err) {
                console.error('批量删除分类失败:', err);
                return res.status(500).json({
                    success: false,
                    message: '批量删除分类失败',
                    error: err.message
                });
            }

            const deletedCategories = checkResults.map(item => ({
                id: item.id,
                name: item.name
            }));

            res.json({
                success: true,
                message: `成功删除 ${result.affectedRows} 个分类`,
                data: {
                    deleted_count: result.affectedRows,
                    deleted_categories: deletedCategories,
                    not_found_ids: notFoundIds.length > 0 ? notFoundIds : undefined
                }
            });
        });
    });
});

/**
 * 删除单个分类 - DELETE /category/:id
 * @description 删除指定ID的分类
 * @param {string} id - 分类UUID
 * @returns {Object} 删除结果
 */
router.delete('/category/:id', (req, res) => {
    const { id } = req.params;

    // UUID格式验证
    if (!isValidUUID(id)) {
        return res.status(400).json({
            success: false,
            message: '无效的分类ID格式'
        });
    }

    // 先检查分类是否存在
    const checkSql = 'SELECT id, name FROM catalog_category WHERE id = ?';
    
    connection.query(checkSql, [id], (err, checkResults) => {
        if (err) {
            console.error('检查分类存在性失败:', err);
            return res.status(500).json({
                success: false,
                message: '检查分类存在性失败',
                error: err.message
            });
        }

        if (checkResults.length === 0) {
            return res.status(404).json({
                success: false,
                message: '分类不存在'
            });
        }

        const categoryName = checkResults[0].name;

        // 执行删除
        const deleteSql = 'DELETE FROM catalog_category WHERE id = ?';

        connection.query(deleteSql, [id], (err, result) => {
            if (err) {
                console.error('删除分类失败:', err);
                return res.status(500).json({
                    success: false,
                    message: '删除分类失败',
                    error: err.message
                });
            }

            res.json({
                success: true,
                message: '分类删除成功',
                data: {
                    id: id,
                    name: categoryName
                }
            });
        });
    });
});
module.exports = router;
